A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever. The following notice applies to the software and data as described below and in the drawing hereto: Copyright (copyright) 1998, Microsoft Corporation, All Rights Reserved.
The present invention involves electronic data processing, and more specifically concerns extensions to programming languages for providing dynamic open-ended modification of a language compiler under the control of source code during compilation of a program.
C++ and other general-purpose programming languages are commonly employed in writing low- to medium-level code for systems such as applications, operating systems, and utility programs. Many programmers rely heavily on libraries of classes specific to the domain of the particular program they are writing. A number of sources make these libraries available to developers. For example, Microsoft(copyright) Foundation Classes (MFC) is a library of C++ classes useful in developing applications for Microsoft Windows(copyright) Active Template Library (ATL) is a library of classes and templates useful in coding components according to the Component Object Model (COM).
Class libraries and similar tools help programmers in several ways. They provide a uniform model or framework for constructing a program. They hide a certain amount of complexity and detail behind simple, easy to use application program interfaces (APIs). For example, hosting an ActiveX control is a significant task for C++ programmers. Using the appropriate available classes reduces the total effort by allowing programmers to concentrate upon coding the actual functionality of the control.
Incorporating these tools into a program, however, requires additional code for fastening together the different classes or other functionalities and for integrating them into the overall program. This additional plumbing or glue code conforms to a general pattern that tends to be repeated many times in a single program. Because it resides in the source code of the program rather than in an external library, this verbose additional code adds complexity and reduces readability. Conventional approaches to hiding detailxe2x80x94macros, include statements, compiler directives, and so forthxe2x80x94have neither the power nor the flexibility to alleviate this problem to any significant degree.
A system of intentional programming, conceived by Charles Simonyi, provides an abstraction mechanism for hiding detail and for providing language features as independent components. This system, however, requires extensive modifications to presently available compilers, and is not dynamically reconfigurable for different applications. Another concept, aspect-oriented programming (AOP), uses self-contained subprograms to modify global properties of an application program. Producing programs in this paradigm requires an entirely new kind of compiler, called a xe2x80x9cweaver.xe2x80x9d
Therefore, a need remains for hiding the complexity that is introduced by the very tools whose purpose is to reduce complexity in writing programs for particular contexts or domains, and to do so without extensive modifications to conventional compilers.
The present invention introduces the concept of attributes that can be attached to programming constructs in source-code for hiding the glue code or any other operations required to employ certain constructs within programs for a specific type of applications. The glue-code or operations may relate to code added to the program at any point, either before or after the attribute is encountered, to modifications of code written by the programmer, to the manner in which certain constructs operate, and to other aspects of the program.
The invention can also be thought of as an instrumentality for extending a programming language in a way that is both powerful and flexible. Extensions for particular purposes become add-in or plug-in modules, easily inserted and easily removed. Different add-ins can be used in sets to provide customized sublanguages for particular problem domains.
When a program is compiled, a simple internal interface added to an otherwise conventional compiler calls an external attribute provider or handler for each of the attribute tags embedded in the source code. The attribute provider can then operate upon any of the code in the program in the compiler to provide the required operations.
Operations upon the code include adding additional code (glue code) to the program, modifying code in the program, deleting code from the program, and changing the manner in which certain constructs function. Operations can also include adding new base classes and switching existing base classes, adding new class members, adding new methods to a class, adding methods or code to existing methods, and adding new entries to a COM map, a MSG map, or a COLUMN map. Many other operations are also possible. The effects of these new attributes can occur at points within the program removed from the point at which the attribute tags occur. For example, an attribute can inject additional code lines at any point in a program source file, whereas a conventional macro can only expand a line of code at the point where the macro statement occurs.
Beyond providing a simple mechanism for hiding details with minimal compiler modifications, the invention offers easy reconfigurability and modifiability for compilers. Because the attribute providers are external to the compiler, they can be changed and upgraded separately, without requiring a new release, or even a new build, of the entire compiler. Vendors can supply different groups of attribute compilers for different purposes, such as for writing Microsoft Active(copyright) controls. Third parties can employ the interface to supply specialized or improved attribute providers for compilers sold by other manufacturers.